import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxAllstar2021VoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAllstar2021VoteVotePost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxAllstar2021VoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAllstar2021VoteVotePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/allstar2021_vote/vote
[apiInstance ajaxAllstar2021VoteVotePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxAllstar2021VoteVotePost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxAllstar2021VoteVotePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/allstar2021_vote/vote
                apiInstance.ajaxAllstar2021VoteVotePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxAllstar2021VoteVotePost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxAllstar2021VoteVotePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxAllstar2021VoteVotePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxAllstar2021VoteVotePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxAllstar2021VoteVotePost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/allstar2021_vote/vote
    api_instance.ajax_allstar2021_vote_vote_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxAllstar2021VoteVotePost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxAllstar2021VoteVotePost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxAllstarVoteSetReadDisplayDialogPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAllstarVoteSetReadDisplayDialogPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxAllstarVoteSetReadDisplayDialogPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAllstarVoteSetReadDisplayDialogPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/allstar_vote/set_read_display_dialog
[apiInstance ajaxAllstarVoteSetReadDisplayDialogPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxAllstarVoteSetReadDisplayDialogPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxAllstarVoteSetReadDisplayDialogPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/allstar_vote/set_read_display_dialog
                apiInstance.ajaxAllstarVoteSetReadDisplayDialogPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxAllstarVoteSetReadDisplayDialogPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxAllstarVoteSetReadDisplayDialogPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxAllstarVoteSetReadDisplayDialogPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxAllstarVoteSetReadDisplayDialogPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxAllstarVoteSetReadDisplayDialogPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/allstar_vote/set_read_display_dialog
    api_instance.ajax_allstar_vote_set_read_display_dialog_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxAllstarVoteSetReadDisplayDialogPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxAllstarVoteSetReadDisplayDialogPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxAllstarVoteVoteGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAllstarVoteVoteGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxAllstarVoteVoteGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAllstarVoteVoteGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];

// ajax/allstar_vote/reset_vote
[apiInstance ajaxAllstarVoteVoteGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxAllstarVoteVoteGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxAllstarVoteVoteGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();

            try {
                // ajax/allstar_vote/reset_vote
                apiInstance.ajaxAllstarVoteVoteGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxAllstarVoteVoteGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();

try {
    $api_instance->ajaxAllstarVoteVoteGet();
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxAllstarVoteVoteGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();

eval {
    $api_instance->ajaxAllstarVoteVoteGet();
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxAllstarVoteVoteGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()

try:
    # ajax/allstar_vote/reset_vote
    api_instance.ajax_allstar_vote_vote_get()
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxAllstarVoteVoteGet: %s\n" % e)

extern crate AjaxApi;

pub fn main() {

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxAllstarVoteVoteGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxAllstarVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAllstarVoteVotePost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxAllstarVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAllstarVoteVotePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/allstar_vote/vote
[apiInstance ajaxAllstarVoteVotePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxAllstarVoteVotePost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxAllstarVoteVotePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/allstar_vote/vote
                apiInstance.ajaxAllstarVoteVotePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxAllstarVoteVotePost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxAllstarVoteVotePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxAllstarVoteVotePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxAllstarVoteVotePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxAllstarVoteVotePost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/allstar_vote/vote
    api_instance.ajax_allstar_vote_vote_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxAllstarVoteVotePost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxAllstarVoteVotePost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxAltairVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAltairVoteVotePost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxAltairVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAltairVoteVotePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/altair_vote/vote
[apiInstance ajaxAltairVoteVotePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxAltairVoteVotePost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxAltairVoteVotePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/altair_vote/vote
                apiInstance.ajaxAltairVoteVotePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxAltairVoteVotePost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxAltairVoteVotePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxAltairVoteVotePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxAltairVoteVotePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxAltairVoteVotePost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/altair_vote/vote
    api_instance.ajax_altair_vote_vote_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxAltairVoteVotePost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxAltairVoteVotePost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxAuthPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAuthPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxAuthPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAuthPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/auth
[apiInstance ajaxAuthPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxAuthPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxAuthPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/auth
                apiInstance.ajaxAuthPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxAuthPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxAuthPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxAuthPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxAuthPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxAuthPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/auth
    api_instance.ajax_auth_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxAuthPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxAuthPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxBlockPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxBlockPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxBlockPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxBlockPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/block
[apiInstance ajaxBlockPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxBlockPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxBlockPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/block
                apiInstance.ajaxBlockPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxBlockPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxBlockPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxBlockPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxBlockPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxBlockPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/block
    api_instance.ajax_block_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxBlockPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxBlockPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxCardSeriesVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxCardSeriesVoteVotePost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxCardSeriesVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxCardSeriesVoteVotePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/card_series_vote/vote
[apiInstance ajaxCardSeriesVoteVotePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxCardSeriesVoteVotePost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxCardSeriesVoteVotePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/card_series_vote/vote
                apiInstance.ajaxCardSeriesVoteVotePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxCardSeriesVoteVotePost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxCardSeriesVoteVotePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxCardSeriesVoteVotePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxCardSeriesVoteVotePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxCardSeriesVoteVotePost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/card_series_vote/vote
    api_instance.ajax_card_series_vote_vote_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxCardSeriesVoteVotePost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxCardSeriesVoteVotePost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxCheckPurchasablePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxCheckPurchasablePost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxCheckPurchasablePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxCheckPurchasablePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/check_purchasable
[apiInstance ajaxCheckPurchasablePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxCheckPurchasablePost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxCheckPurchasablePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/check_purchasable
                apiInstance.ajaxCheckPurchasablePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxCheckPurchasablePost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxCheckPurchasablePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxCheckPurchasablePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxCheckPurchasablePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxCheckPurchasablePost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/check_purchasable
    api_instance.ajax_check_purchasable_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxCheckPurchasablePost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxCheckPurchasablePost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxDebugTerminalReplaceGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxDebugTerminalReplaceGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxDebugTerminalReplaceGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxDebugTerminalReplaceGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];

// ajax/debug_terminal/replace
[apiInstance ajaxDebugTerminalReplaceGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxDebugTerminalReplaceGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxDebugTerminalReplaceGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();

            try {
                // ajax/debug_terminal/replace
                apiInstance.ajaxDebugTerminalReplaceGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxDebugTerminalReplaceGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();

try {
    $api_instance->ajaxDebugTerminalReplaceGet();
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxDebugTerminalReplaceGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();

eval {
    $api_instance->ajaxDebugTerminalReplaceGet();
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxDebugTerminalReplaceGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()

try:
    # ajax/debug_terminal/replace
    api_instance.ajax_debug_terminal_replace_get()
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxDebugTerminalReplaceGet: %s\n" % e)

extern crate AjaxApi;

pub fn main() {

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxDebugTerminalReplaceGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxDreamteamSetDeckPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxDreamteamSetDeckPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxDreamteamSetDeckPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxDreamteamSetDeckPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/dreamteam/set_deck
[apiInstance ajaxDreamteamSetDeckPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxDreamteamSetDeckPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxDreamteamSetDeckPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/dreamteam/set_deck
                apiInstance.ajaxDreamteamSetDeckPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxDreamteamSetDeckPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxDreamteamSetDeckPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxDreamteamSetDeckPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxDreamteamSetDeckPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxDreamteamSetDeckPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/dreamteam/set_deck
    api_instance.ajax_dreamteam_set_deck_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxDreamteamSetDeckPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxDreamteamSetDeckPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxDreamteamSetPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxDreamteamSetPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxDreamteamSetPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxDreamteamSetPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/dreamteam/set
[apiInstance ajaxDreamteamSetPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxDreamteamSetPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxDreamteamSetPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/dreamteam/set
                apiInstance.ajaxDreamteamSetPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxDreamteamSetPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxDreamteamSetPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxDreamteamSetPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxDreamteamSetPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxDreamteamSetPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/dreamteam/set
    api_instance.ajax_dreamteam_set_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxDreamteamSetPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxDreamteamSetPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxDreamteamVoteVoteGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxDreamteamVoteVoteGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxDreamteamVoteVoteGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxDreamteamVoteVoteGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];

// ajax/allstar2021_vote/reset_vote
[apiInstance ajaxDreamteamVoteVoteGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxDreamteamVoteVoteGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxDreamteamVoteVoteGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();

            try {
                // ajax/allstar2021_vote/reset_vote
                apiInstance.ajaxDreamteamVoteVoteGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxDreamteamVoteVoteGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();

try {
    $api_instance->ajaxDreamteamVoteVoteGet();
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxDreamteamVoteVoteGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();

eval {
    $api_instance->ajaxDreamteamVoteVoteGet();
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxDreamteamVoteVoteGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()

try:
    # ajax/allstar2021_vote/reset_vote
    api_instance.ajax_dreamteam_vote_vote_get()
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxDreamteamVoteVoteGet: %s\n" % e)

extern crate AjaxApi;

pub fn main() {

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxDreamteamVoteVoteGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxDreamteamVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxDreamteamVoteVotePost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxDreamteamVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxDreamteamVoteVotePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/dreamteam_vote/vote
[apiInstance ajaxDreamteamVoteVotePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxDreamteamVoteVotePost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxDreamteamVoteVotePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/dreamteam_vote/vote
                apiInstance.ajaxDreamteamVoteVotePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxDreamteamVoteVotePost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxDreamteamVoteVotePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxDreamteamVoteVotePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxDreamteamVoteVotePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxDreamteamVoteVotePost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/dreamteam_vote/vote
    api_instance.ajax_dreamteam_vote_vote_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxDreamteamVoteVotePost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxDreamteamVoteVotePost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastClearCardPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastClearCardPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastClearCardPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastClearCardPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/forecast/clear_card
[apiInstance ajaxForecastClearCardPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastClearCardPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastClearCardPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/forecast/clear_card
                apiInstance.ajaxForecastClearCardPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastClearCardPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxForecastClearCardPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastClearCardPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxForecastClearCardPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastClearCardPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/forecast/clear_card
    api_instance.ajax_forecast_clear_card_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastClearCardPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastClearCardPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastExchangeRewardPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastExchangeRewardPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastExchangeRewardPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastExchangeRewardPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/forecast/exchange_reward
[apiInstance ajaxForecastExchangeRewardPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastExchangeRewardPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastExchangeRewardPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/forecast/exchange_reward
                apiInstance.ajaxForecastExchangeRewardPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastExchangeRewardPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxForecastExchangeRewardPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastExchangeRewardPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxForecastExchangeRewardPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastExchangeRewardPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/forecast/exchange_reward
    api_instance.ajax_forecast_exchange_reward_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastExchangeRewardPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastExchangeRewardPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxForecastExecAutoCardSetGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastExecAutoCardSetGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxForecastExecAutoCardSetGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastExecAutoCardSetGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];

// ajax/forecast/exec_auto_card_set
[apiInstance ajaxForecastExecAutoCardSetGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastExecAutoCardSetGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastExecAutoCardSetGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();

            try {
                // ajax/forecast/exec_auto_card_set
                apiInstance.ajaxForecastExecAutoCardSetGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastExecAutoCardSetGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();

try {
    $api_instance->ajaxForecastExecAutoCardSetGet();
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastExecAutoCardSetGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();

eval {
    $api_instance->ajaxForecastExecAutoCardSetGet();
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastExecAutoCardSetGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()

try:
    # ajax/forecast/exec_auto_card_set
    api_instance.ajax_forecast_exec_auto_card_set_get()
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastExecAutoCardSetGet: %s\n" % e)

extern crate AjaxApi;

pub fn main() {

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastExecAutoCardSetGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxForecastGetBadgeSettingGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastGetBadgeSettingGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxForecastGetBadgeSettingGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastGetBadgeSettingGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];

// ajax/forecast/get_badge_setting
[apiInstance ajaxForecastGetBadgeSettingGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastGetBadgeSettingGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastGetBadgeSettingGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();

            try {
                // ajax/forecast/get_badge_setting
                apiInstance.ajaxForecastGetBadgeSettingGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastGetBadgeSettingGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();

try {
    $api_instance->ajaxForecastGetBadgeSettingGet();
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastGetBadgeSettingGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();

eval {
    $api_instance->ajaxForecastGetBadgeSettingGet();
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastGetBadgeSettingGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()

try:
    # ajax/forecast/get_badge_setting
    api_instance.ajax_forecast_get_badge_setting_get()
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastGetBadgeSettingGet: %s\n" % e)

extern crate AjaxApi;

pub fn main() {

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastGetBadgeSettingGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxForecastGetGameScheduleGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastGetGameScheduleGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxForecastGetGameScheduleGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastGetGameScheduleGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];

// ajax/forecast/get_game_schedule
[apiInstance ajaxForecastGetGameScheduleGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastGetGameScheduleGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastGetGameScheduleGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();

            try {
                // ajax/forecast/get_game_schedule
                apiInstance.ajaxForecastGetGameScheduleGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastGetGameScheduleGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();

try {
    $api_instance->ajaxForecastGetGameScheduleGet();
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastGetGameScheduleGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();

eval {
    $api_instance->ajaxForecastGetGameScheduleGet();
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastGetGameScheduleGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()

try:
    # ajax/forecast/get_game_schedule
    api_instance.ajax_forecast_get_game_schedule_get()
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastGetGameScheduleGet: %s\n" % e)

extern crate AjaxApi;

pub fn main() {

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastGetGameScheduleGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastGetSeasonRanksPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastGetSeasonRanksPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastGetSeasonRanksPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastGetSeasonRanksPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/forecast/get_season_ranks
[apiInstance ajaxForecastGetSeasonRanksPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastGetSeasonRanksPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastGetSeasonRanksPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/forecast/get_season_ranks
                apiInstance.ajaxForecastGetSeasonRanksPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastGetSeasonRanksPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxForecastGetSeasonRanksPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastGetSeasonRanksPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxForecastGetSeasonRanksPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastGetSeasonRanksPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/forecast/get_season_ranks
    api_instance.ajax_forecast_get_season_ranks_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastGetSeasonRanksPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastGetSeasonRanksPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastGetSectionRanksPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastGetSectionRanksPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastGetSectionRanksPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastGetSectionRanksPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/forecast/get_section_ranks
[apiInstance ajaxForecastGetSectionRanksPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastGetSectionRanksPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastGetSectionRanksPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/forecast/get_section_ranks
                apiInstance.ajaxForecastGetSectionRanksPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastGetSectionRanksPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxForecastGetSectionRanksPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastGetSectionRanksPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxForecastGetSectionRanksPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastGetSectionRanksPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/forecast/get_section_ranks
    api_instance.ajax_forecast_get_section_ranks_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastGetSectionRanksPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastGetSectionRanksPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastIsSlotEditablePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastIsSlotEditablePost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastIsSlotEditablePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastIsSlotEditablePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/forecast/is_slot_editable
[apiInstance ajaxForecastIsSlotEditablePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastIsSlotEditablePost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastIsSlotEditablePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/forecast/is_slot_editable
                apiInstance.ajaxForecastIsSlotEditablePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastIsSlotEditablePost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxForecastIsSlotEditablePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastIsSlotEditablePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxForecastIsSlotEditablePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastIsSlotEditablePost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/forecast/is_slot_editable
    api_instance.ajax_forecast_is_slot_editable_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastIsSlotEditablePost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastIsSlotEditablePost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastSaveCardsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastSaveCardsPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastSaveCardsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastSaveCardsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/forecast/save_cards
[apiInstance ajaxForecastSaveCardsPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastSaveCardsPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastSaveCardsPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/forecast/save_cards
                apiInstance.ajaxForecastSaveCardsPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastSaveCardsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxForecastSaveCardsPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastSaveCardsPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxForecastSaveCardsPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastSaveCardsPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/forecast/save_cards
    api_instance.ajax_forecast_save_cards_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastSaveCardsPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastSaveCardsPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastSelectCardPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastSelectCardPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastSelectCardPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastSelectCardPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/forecast/select_card
[apiInstance ajaxForecastSelectCardPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastSelectCardPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastSelectCardPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/forecast/select_card
                apiInstance.ajaxForecastSelectCardPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastSelectCardPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxForecastSelectCardPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastSelectCardPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxForecastSelectCardPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastSelectCardPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/forecast/select_card
    api_instance.ajax_forecast_select_card_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastSelectCardPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastSelectCardPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastSetBadgePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastSetBadgePost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastSetBadgePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastSetBadgePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/forecast/set_badge
[apiInstance ajaxForecastSetBadgePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastSetBadgePost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastSetBadgePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/forecast/set_badge
                apiInstance.ajaxForecastSetBadgePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastSetBadgePost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxForecastSetBadgePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastSetBadgePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxForecastSetBadgePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastSetBadgePost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/forecast/set_badge
    api_instance.ajax_forecast_set_badge_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastSetBadgePost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastSetBadgePost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxMascotVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxMascotVoteVotePost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxMascotVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxMascotVoteVotePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/mascot_vote/vote
[apiInstance ajaxMascotVoteVotePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxMascotVoteVotePost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxMascotVoteVotePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/mascot_vote/vote
                apiInstance.ajaxMascotVoteVotePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxMascotVoteVotePost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxMascotVoteVotePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxMascotVoteVotePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxMascotVoteVotePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxMascotVoteVotePost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/mascot_vote/vote
    api_instance.ajax_mascot_vote_vote_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxMascotVoteVotePost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxMascotVoteVotePost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxMinimailBlockPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxMinimailBlockPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxMinimailBlockPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxMinimailBlockPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/minimail/block
[apiInstance ajaxMinimailBlockPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxMinimailBlockPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxMinimailBlockPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/minimail/block
                apiInstance.ajaxMinimailBlockPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxMinimailBlockPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxMinimailBlockPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxMinimailBlockPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxMinimailBlockPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxMinimailBlockPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/minimail/block
    api_instance.ajax_minimail_block_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxMinimailBlockPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxMinimailBlockPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxMinimailListPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxMinimailListPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxMinimailListPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxMinimailListPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/minimail/list
[apiInstance ajaxMinimailListPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxMinimailListPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxMinimailListPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/minimail/list
                apiInstance.ajaxMinimailListPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxMinimailListPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxMinimailListPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxMinimailListPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxMinimailListPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxMinimailListPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/minimail/list
    api_instance.ajax_minimail_list_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxMinimailListPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxMinimailListPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxMinimailPullAnyPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxMinimailPullAnyPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxMinimailPullAnyPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxMinimailPullAnyPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/minimail/pull/(:any)
[apiInstance ajaxMinimailPullAnyPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxMinimailPullAnyPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxMinimailPullAnyPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/minimail/pull/(:any)
                apiInstance.ajaxMinimailPullAnyPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxMinimailPullAnyPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxMinimailPullAnyPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxMinimailPullAnyPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxMinimailPullAnyPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxMinimailPullAnyPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/minimail/pull/(:any)
    api_instance.ajax_minimail_pull_any_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxMinimailPullAnyPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxMinimailPullAnyPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxNoticePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxNoticePost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxNoticePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxNoticePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/notice
[apiInstance ajaxNoticePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxNoticePost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxNoticePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/notice
                apiInstance.ajaxNoticePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxNoticePost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxNoticePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxNoticePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxNoticePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxNoticePost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/notice
    api_instance.ajax_notice_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxNoticePost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxNoticePost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxNoticeSetMyClubPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxNoticeSetMyClubPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxNoticeSetMyClubPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxNoticeSetMyClubPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax_notice_set_my_club
[apiInstance ajaxNoticeSetMyClubPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxNoticeSetMyClubPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxNoticeSetMyClubPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax_notice_set_my_club
                apiInstance.ajaxNoticeSetMyClubPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxNoticeSetMyClubPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxNoticeSetMyClubPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxNoticeSetMyClubPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxNoticeSetMyClubPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxNoticeSetMyClubPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax_notice_set_my_club
    api_instance.ajax_notice_set_my_club_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxNoticeSetMyClubPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxNoticeSetMyClubPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPostUploadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPostUploadPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPostUploadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPostUploadPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/post/upload
[apiInstance ajaxPostUploadPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxPostUploadPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxPostUploadPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/post/upload
                apiInstance.ajaxPostUploadPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxPostUploadPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxPostUploadPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxPostUploadPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxPostUploadPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxPostUploadPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/post/upload
    api_instance.ajax_post_upload_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxPostUploadPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxPostUploadPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxPullUserNoticeGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPullUserNoticeGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxPullUserNoticeGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPullUserNoticeGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];

// ajax_pull_user_notice
[apiInstance ajaxPullUserNoticeGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxPullUserNoticeGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxPullUserNoticeGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();

            try {
                // ajax_pull_user_notice
                apiInstance.ajaxPullUserNoticeGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxPullUserNoticeGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();

try {
    $api_instance->ajaxPullUserNoticeGet();
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxPullUserNoticeGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();

eval {
    $api_instance->ajaxPullUserNoticeGet();
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxPullUserNoticeGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()

try:
    # ajax_pull_user_notice
    api_instance.ajax_pull_user_notice_get()
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxPullUserNoticeGet: %s\n" % e)

extern crate AjaxApi;

pub fn main() {

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxPullUserNoticeGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxPurchaseItemsGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPurchaseItemsGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxPurchaseItemsGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPurchaseItemsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];

// ajax/purchase_items
[apiInstance ajaxPurchaseItemsGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxPurchaseItemsGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxPurchaseItemsGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();

            try {
                // ajax/purchase_items
                apiInstance.ajaxPurchaseItemsGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxPurchaseItemsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();

try {
    $api_instance->ajaxPurchaseItemsGet();
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxPurchaseItemsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();

eval {
    $api_instance->ajaxPurchaseItemsGet();
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxPurchaseItemsGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()

try:
    # ajax/purchase_items
    api_instance.ajax_purchase_items_get()
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxPurchaseItemsGet: %s\n" % e)

extern crate AjaxApi;

pub fn main() {

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxPurchaseItemsGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPushCardNewReadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPushCardNewReadPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPushCardNewReadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPushCardNewReadPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax_push_card_new_read
[apiInstance ajaxPushCardNewReadPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxPushCardNewReadPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxPushCardNewReadPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax_push_card_new_read
                apiInstance.ajaxPushCardNewReadPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxPushCardNewReadPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxPushCardNewReadPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxPushCardNewReadPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxPushCardNewReadPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxPushCardNewReadPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax_push_card_new_read
    api_instance.ajax_push_card_new_read_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxPushCardNewReadPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxPushCardNewReadPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPushOshiraseOkPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPushOshiraseOkPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPushOshiraseOkPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPushOshiraseOkPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax_push_oshirase_ok
[apiInstance ajaxPushOshiraseOkPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxPushOshiraseOkPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxPushOshiraseOkPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax_push_oshirase_ok
                apiInstance.ajaxPushOshiraseOkPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxPushOshiraseOkPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxPushOshiraseOkPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxPushOshiraseOkPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxPushOshiraseOkPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxPushOshiraseOkPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax_push_oshirase_ok
    api_instance.ajax_push_oshirase_ok_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxPushOshiraseOkPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxPushOshiraseOkPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPushOshiraseReadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPushOshiraseReadPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPushOshiraseReadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPushOshiraseReadPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax_push_oshirase_read
[apiInstance ajaxPushOshiraseReadPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxPushOshiraseReadPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxPushOshiraseReadPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax_push_oshirase_read
                apiInstance.ajaxPushOshiraseReadPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxPushOshiraseReadPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxPushOshiraseReadPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxPushOshiraseReadPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxPushOshiraseReadPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxPushOshiraseReadPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax_push_oshirase_read
    api_instance.ajax_push_oshirase_read_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxPushOshiraseReadPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxPushOshiraseReadPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPushUserNoticeReadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPushUserNoticeReadPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPushUserNoticeReadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPushUserNoticeReadPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax_push_user_notice_read
[apiInstance ajaxPushUserNoticeReadPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxPushUserNoticeReadPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxPushUserNoticeReadPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax_push_user_notice_read
                apiInstance.ajaxPushUserNoticeReadPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxPushUserNoticeReadPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxPushUserNoticeReadPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxPushUserNoticeReadPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxPushUserNoticeReadPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxPushUserNoticeReadPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax_push_user_notice_read
    api_instance.ajax_push_user_notice_read_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxPushUserNoticeReadPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxPushUserNoticeReadPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPushUserOshirasesReadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPushUserOshirasesReadPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPushUserOshirasesReadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPushUserOshirasesReadPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax_push_user_oshirases_read
[apiInstance ajaxPushUserOshirasesReadPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxPushUserOshirasesReadPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxPushUserOshirasesReadPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax_push_user_oshirases_read
                apiInstance.ajaxPushUserOshirasesReadPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxPushUserOshirasesReadPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxPushUserOshirasesReadPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxPushUserOshirasesReadPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxPushUserOshirasesReadPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxPushUserOshirasesReadPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax_push_user_oshirases_read
    api_instance.ajax_push_user_oshirases_read_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxPushUserOshirasesReadPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxPushUserOshirasesReadPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxSaveHavingFilterPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxSaveHavingFilterPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxSaveHavingFilterPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxSaveHavingFilterPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax_save_having_filter
[apiInstance ajaxSaveHavingFilterPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxSaveHavingFilterPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxSaveHavingFilterPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax_save_having_filter
                apiInstance.ajaxSaveHavingFilterPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxSaveHavingFilterPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxSaveHavingFilterPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxSaveHavingFilterPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxSaveHavingFilterPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxSaveHavingFilterPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax_save_having_filter
    api_instance.ajax_save_having_filter_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxSaveHavingFilterPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxSaveHavingFilterPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxSaveHolderSortPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxSaveHolderSortPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxSaveHolderSortPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxSaveHolderSortPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax_save_holder_sort
[apiInstance ajaxSaveHolderSortPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxSaveHolderSortPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxSaveHolderSortPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax_save_holder_sort
                apiInstance.ajaxSaveHolderSortPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxSaveHolderSortPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxSaveHolderSortPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxSaveHolderSortPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxSaveHolderSortPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxSaveHolderSortPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax_save_holder_sort
    api_instance.ajax_save_holder_sort_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxSaveHolderSortPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxSaveHolderSortPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxSearchUidPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxSearchUidPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxSearchUidPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxSearchUidPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/search_uid
[apiInstance ajaxSearchUidPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxSearchUidPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxSearchUidPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/search_uid
                apiInstance.ajaxSearchUidPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxSearchUidPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxSearchUidPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxSearchUidPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxSearchUidPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxSearchUidPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/search_uid
    api_instance.ajax_search_uid_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxSearchUidPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxSearchUidPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxValentine2021VoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxValentine2021VoteVotePost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxValentine2021VoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxValentine2021VoteVotePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/valentine2021_vote/vote
[apiInstance ajaxValentine2021VoteVotePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxValentine2021VoteVotePost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxValentine2021VoteVotePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/valentine2021_vote/vote
                apiInstance.ajaxValentine2021VoteVotePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxValentine2021VoteVotePost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxValentine2021VoteVotePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxValentine2021VoteVotePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxValentine2021VoteVotePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxValentine2021VoteVotePost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/valentine2021_vote/vote
    api_instance.ajax_valentine2021_vote_vote_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxValentine2021VoteVotePost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxValentine2021VoteVotePost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxValentineVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxValentineVoteVotePost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxValentineVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxValentineVoteVotePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/valentine_vote/vote
[apiInstance ajaxValentineVoteVotePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxValentineVoteVotePost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxValentineVoteVotePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/valentine_vote/vote
                apiInstance.ajaxValentineVoteVotePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxValentineVoteVotePost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxValentineVoteVotePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxValentineVoteVotePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxValentineVoteVotePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxValentineVoteVotePost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/valentine_vote/vote
    api_instance.ajax_valentine_vote_vote_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxValentineVoteVotePost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxValentineVoteVotePost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.userAjaxActivitiesPullPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#userAjaxActivitiesPullPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.userAjaxActivitiesPullPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#userAjaxActivitiesPullPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/activities/pull
[apiInstance userAjaxActivitiesPullPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.userAjaxActivitiesPullPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class userAjaxActivitiesPullPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/activities/pull
                apiInstance.userAjaxActivitiesPullPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.userAjaxActivitiesPullPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->userAjaxActivitiesPullPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->userAjaxActivitiesPullPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->userAjaxActivitiesPullPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->userAjaxActivitiesPullPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/activities/pull
    api_instance.user_ajax_activities_pull_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->userAjaxActivitiesPullPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.userAjaxActivitiesPullPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.userAjaxPullPointhistoryPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#userAjaxPullPointhistoryPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.userAjaxPullPointhistoryPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#userAjaxPullPointhistoryPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax_pull_pointhistory
[apiInstance userAjaxPullPointhistoryPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.userAjaxPullPointhistoryPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class userAjaxPullPointhistoryPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax_pull_pointhistory
                apiInstance.userAjaxPullPointhistoryPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.userAjaxPullPointhistoryPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->userAjaxPullPointhistoryPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->userAjaxPullPointhistoryPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->userAjaxPullPointhistoryPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->userAjaxPullPointhistoryPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax_pull_pointhistory
    api_instance.user_ajax_pull_pointhistory_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->userAjaxPullPointhistoryPost: %s\n" % e)

extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.userAjaxPullPointhistoryPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.Allstar2021VoteApi;

import java.io.File;
import java.util.*;

public class Allstar2021VoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        Allstar2021VoteApi apiInstance = new Allstar2021VoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.allstar2021VoteGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling Allstar2021VoteApi#allstar2021VoteGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.Allstar2021VoteApi;

public class Allstar2021VoteApiExample {
    public static void main(String[] args) {
        Allstar2021VoteApi apiInstance = new Allstar2021VoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.allstar2021VoteGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling Allstar2021VoteApi#allstar2021VoteGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
Allstar2021VoteApi *apiInstance = [[Allstar2021VoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)
String *targetYear = yyyy; //  (optional) (default to null)

// allstar2021_vote
[apiInstance allstar2021VoteGetWith:userAgent
    targetYear:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.Allstar2021VoteApi()
var opts = {
  'userAgent': userAgent_example, // {String} 
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.allstar2021VoteGet(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class allstar2021VoteGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new Allstar2021VoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // allstar2021_vote
                apiInstance.allstar2021VoteGet(userAgent, targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling Allstar2021VoteApi.allstar2021VoteGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Allstar2021VoteApi();
$userAgent = userAgent_example; // String | 
$targetYear = yyyy; // String | 

try {
    $api_instance->allstar2021VoteGet($userAgent, $targetYear);
} catch (Exception $e) {
    echo 'Exception when calling Allstar2021VoteApi->allstar2021VoteGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Allstar2021VoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Allstar2021VoteApi->new();
my $userAgent = userAgent_example; # String | 
my $targetYear = yyyy; # String | 

eval {
    $api_instance->allstar2021VoteGet(userAgent => $userAgent, targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling Allstar2021VoteApi->allstar2021VoteGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.Allstar2021VoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)
targetYear = yyyy # String |  (optional) (default to null)

try:
    # allstar2021_vote
    api_instance.allstar2021_vote_get(userAgent=userAgent, targetYear=targetYear)
except ApiException as e:
    print("Exception when calling Allstar2021VoteApi->allstar2021VoteGet: %s\n" % e)

extern crate Allstar2021VoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let targetYear = yyyy; // String

    let mut context = Allstar2021VoteApi::Context::default();
    let result = client.allstar2021VoteGet(userAgent, targetYear, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.Allstar2021VoteApi;

import java.io.File;
import java.util.*;

public class Allstar2021VoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        Allstar2021VoteApi apiInstance = new Allstar2021VoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.allstar2021VoteIndexApiGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling Allstar2021VoteApi#allstar2021VoteIndexApiGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.Allstar2021VoteApi;

public class Allstar2021VoteApiExample {
    public static void main(String[] args) {
        Allstar2021VoteApi apiInstance = new Allstar2021VoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.allstar2021VoteIndexApiGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling Allstar2021VoteApi#allstar2021VoteIndexApiGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
Allstar2021VoteApi *apiInstance = [[Allstar2021VoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)
String *targetYear = yyyy; //  (optional) (default to null)

// allstar2021_vote/index_api
[apiInstance allstar2021VoteIndexApiGetWith:userAgent
    targetYear:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.Allstar2021VoteApi()
var opts = {
  'userAgent': userAgent_example, // {String} 
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.allstar2021VoteIndexApiGet(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class allstar2021VoteIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new Allstar2021VoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // allstar2021_vote/index_api
                apiInstance.allstar2021VoteIndexApiGet(userAgent, targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling Allstar2021VoteApi.allstar2021VoteIndexApiGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Allstar2021VoteApi();
$userAgent = userAgent_example; // String | 
$targetYear = yyyy; // String | 

try {
    $api_instance->allstar2021VoteIndexApiGet($userAgent, $targetYear);
} catch (Exception $e) {
    echo 'Exception when calling Allstar2021VoteApi->allstar2021VoteIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Allstar2021VoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Allstar2021VoteApi->new();
my $userAgent = userAgent_example; # String | 
my $targetYear = yyyy; # String | 

eval {
    $api_instance->allstar2021VoteIndexApiGet(userAgent => $userAgent, targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling Allstar2021VoteApi->allstar2021VoteIndexApiGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.Allstar2021VoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)
targetYear = yyyy # String |  (optional) (default to null)

try:
    # allstar2021_vote/index_api
    api_instance.allstar2021_vote_index_api_get(userAgent=userAgent, targetYear=targetYear)
except ApiException as e:
    print("Exception when calling Allstar2021VoteApi->allstar2021VoteIndexApiGet: %s\n" % e)

extern crate Allstar2021VoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let targetYear = yyyy; // String

    let mut context = Allstar2021VoteApi::Context::default();
    let result = client.allstar2021VoteIndexApiGet(userAgent, targetYear, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AllstarVoteApi;

import java.io.File;
import java.util.*;

public class AllstarVoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AllstarVoteApi apiInstance = new AllstarVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.allstarVoteGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling AllstarVoteApi#allstarVoteGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AllstarVoteApi;

public class AllstarVoteApiExample {
    public static void main(String[] args) {
        AllstarVoteApi apiInstance = new AllstarVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.allstarVoteGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling AllstarVoteApi#allstarVoteGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AllstarVoteApi *apiInstance = [[AllstarVoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)
String *targetYear = yyyy; //  (optional) (default to null)

// allstar_vote
[apiInstance allstarVoteGetWith:userAgent
    targetYear:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AllstarVoteApi()
var opts = {
  'userAgent': userAgent_example, // {String} 
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.allstarVoteGet(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class allstarVoteGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AllstarVoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // allstar_vote
                apiInstance.allstarVoteGet(userAgent, targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling AllstarVoteApi.allstarVoteGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AllstarVoteApi();
$userAgent = userAgent_example; // String | 
$targetYear = yyyy; // String | 

try {
    $api_instance->allstarVoteGet($userAgent, $targetYear);
} catch (Exception $e) {
    echo 'Exception when calling AllstarVoteApi->allstarVoteGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AllstarVoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AllstarVoteApi->new();
my $userAgent = userAgent_example; # String | 
my $targetYear = yyyy; # String | 

eval {
    $api_instance->allstarVoteGet(userAgent => $userAgent, targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling AllstarVoteApi->allstarVoteGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AllstarVoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)
targetYear = yyyy # String |  (optional) (default to null)

try:
    # allstar_vote
    api_instance.allstar_vote_get(userAgent=userAgent, targetYear=targetYear)
except ApiException as e:
    print("Exception when calling AllstarVoteApi->allstarVoteGet: %s\n" % e)

extern crate AllstarVoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let targetYear = yyyy; // String

    let mut context = AllstarVoteApi::Context::default();
    let result = client.allstarVoteGet(userAgent, targetYear, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AllstarVoteApi;

import java.io.File;
import java.util.*;

public class AllstarVoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AllstarVoteApi apiInstance = new AllstarVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.allstarVoteIndexApiGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling AllstarVoteApi#allstarVoteIndexApiGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AllstarVoteApi;

public class AllstarVoteApiExample {
    public static void main(String[] args) {
        AllstarVoteApi apiInstance = new AllstarVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.allstarVoteIndexApiGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling AllstarVoteApi#allstarVoteIndexApiGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AllstarVoteApi *apiInstance = [[AllstarVoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)
String *targetYear = yyyy; //  (optional) (default to null)

// allstar_vote/index_api
[apiInstance allstarVoteIndexApiGetWith:userAgent
    targetYear:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AllstarVoteApi()
var opts = {
  'userAgent': userAgent_example, // {String} 
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.allstarVoteIndexApiGet(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class allstarVoteIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AllstarVoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // allstar_vote/index_api
                apiInstance.allstarVoteIndexApiGet(userAgent, targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling AllstarVoteApi.allstarVoteIndexApiGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AllstarVoteApi();
$userAgent = userAgent_example; // String | 
$targetYear = yyyy; // String | 

try {
    $api_instance->allstarVoteIndexApiGet($userAgent, $targetYear);
} catch (Exception $e) {
    echo 'Exception when calling AllstarVoteApi->allstarVoteIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AllstarVoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AllstarVoteApi->new();
my $userAgent = userAgent_example; # String | 
my $targetYear = yyyy; # String | 

eval {
    $api_instance->allstarVoteIndexApiGet(userAgent => $userAgent, targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling AllstarVoteApi->allstarVoteIndexApiGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AllstarVoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)
targetYear = yyyy # String |  (optional) (default to null)

try:
    # allstar_vote/index_api
    api_instance.allstar_vote_index_api_get(userAgent=userAgent, targetYear=targetYear)
except ApiException as e:
    print("Exception when calling AllstarVoteApi->allstarVoteIndexApiGet: %s\n" % e)

extern crate AllstarVoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let targetYear = yyyy; // String

    let mut context = AllstarVoteApi::Context::default();
    let result = client.allstarVoteIndexApiGet(userAgent, targetYear, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AltairVoteApi;

import java.io.File;
import java.util.*;

public class AltairVoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AltairVoteApi apiInstance = new AltairVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.altairVoteGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling AltairVoteApi#altairVoteGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AltairVoteApi;

public class AltairVoteApiExample {
    public static void main(String[] args) {
        AltairVoteApi apiInstance = new AltairVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.altairVoteGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling AltairVoteApi#altairVoteGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AltairVoteApi *apiInstance = [[AltairVoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)
String *targetYear = yyyy; //  (optional) (default to null)

// altair_vote
[apiInstance altairVoteGetWith:userAgent
    targetYear:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AltairVoteApi()
var opts = {
  'userAgent': userAgent_example, // {String} 
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.altairVoteGet(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class altairVoteGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AltairVoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // altair_vote
                apiInstance.altairVoteGet(userAgent, targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling AltairVoteApi.altairVoteGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AltairVoteApi();
$userAgent = userAgent_example; // String | 
$targetYear = yyyy; // String | 

try {
    $api_instance->altairVoteGet($userAgent, $targetYear);
} catch (Exception $e) {
    echo 'Exception when calling AltairVoteApi->altairVoteGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AltairVoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AltairVoteApi->new();
my $userAgent = userAgent_example; # String | 
my $targetYear = yyyy; # String | 

eval {
    $api_instance->altairVoteGet(userAgent => $userAgent, targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling AltairVoteApi->altairVoteGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AltairVoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)
targetYear = yyyy # String |  (optional) (default to null)

try:
    # altair_vote
    api_instance.altair_vote_get(userAgent=userAgent, targetYear=targetYear)
except ApiException as e:
    print("Exception when calling AltairVoteApi->altairVoteGet: %s\n" % e)

extern crate AltairVoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let targetYear = yyyy; // String

    let mut context = AltairVoteApi::Context::default();
    let result = client.altairVoteGet(userAgent, targetYear, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AltairVoteApi;

import java.io.File;
import java.util.*;

public class AltairVoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AltairVoteApi apiInstance = new AltairVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.altairVoteIndexApiGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling AltairVoteApi#altairVoteIndexApiGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AltairVoteApi;

public class AltairVoteApiExample {
    public static void main(String[] args) {
        AltairVoteApi apiInstance = new AltairVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.altairVoteIndexApiGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling AltairVoteApi#altairVoteIndexApiGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AltairVoteApi *apiInstance = [[AltairVoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)
String *targetYear = yyyy; //  (optional) (default to null)

// altair_vote/index_api
[apiInstance altairVoteIndexApiGetWith:userAgent
    targetYear:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AltairVoteApi()
var opts = {
  'userAgent': userAgent_example, // {String} 
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.altairVoteIndexApiGet(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class altairVoteIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AltairVoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // altair_vote/index_api
                apiInstance.altairVoteIndexApiGet(userAgent, targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling AltairVoteApi.altairVoteIndexApiGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AltairVoteApi();
$userAgent = userAgent_example; // String | 
$targetYear = yyyy; // String | 

try {
    $api_instance->altairVoteIndexApiGet($userAgent, $targetYear);
} catch (Exception $e) {
    echo 'Exception when calling AltairVoteApi->altairVoteIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AltairVoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AltairVoteApi->new();
my $userAgent = userAgent_example; # String | 
my $targetYear = yyyy; # String | 

eval {
    $api_instance->altairVoteIndexApiGet(userAgent => $userAgent, targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling AltairVoteApi->altairVoteIndexApiGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AltairVoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)
targetYear = yyyy # String |  (optional) (default to null)

try:
    # altair_vote/index_api
    api_instance.altair_vote_index_api_get(userAgent=userAgent, targetYear=targetYear)
except ApiException as e:
    print("Exception when calling AltairVoteApi->altairVoteIndexApiGet: %s\n" % e)

extern crate AltairVoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let targetYear = yyyy; // String

    let mut context = AltairVoteApi::Context::default();
    let result = client.altairVoteIndexApiGet(userAgent, targetYear, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.BLeagueAuthApi;

import java.io.File;
import java.util.*;

public class BLeagueAuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        BLeagueAuthApi apiInstance = new BLeagueAuthApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.bLeagueAuthLinkAccountPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BLeagueAuthApi#bLeagueAuthLinkAccountPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.BLeagueAuthApi;

public class BLeagueAuthApiExample {
    public static void main(String[] args) {
        BLeagueAuthApi apiInstance = new BLeagueAuthApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.bLeagueAuthLinkAccountPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BLeagueAuthApi#bLeagueAuthLinkAccountPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
BLeagueAuthApi *apiInstance = [[BLeagueAuthApi alloc] init];
Object *body = Object; //  (optional)

// link_account
[apiInstance bLeagueAuthLinkAccountPostWith:body
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.BLeagueAuthApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bLeagueAuthLinkAccountPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bLeagueAuthLinkAccountPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new BLeagueAuthApi();
            var body = Object;  // Object |  (optional) 

            try {
                // link_account
                Object result = apiInstance.bLeagueAuthLinkAccountPost(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BLeagueAuthApi.bLeagueAuthLinkAccountPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BLeagueAuthApi();
$body = Object; // Object | 

try {
    $result = $api_instance->bLeagueAuthLinkAccountPost($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BLeagueAuthApi->bLeagueAuthLinkAccountPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::BLeagueAuthApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BLeagueAuthApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    my $result = $api_instance->bLeagueAuthLinkAccountPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BLeagueAuthApi->bLeagueAuthLinkAccountPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.BLeagueAuthApi()
body = Object # Object |  (optional)

try:
    # link_account
    api_response = api_instance.b_league_auth_link_account_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BLeagueAuthApi->bLeagueAuthLinkAccountPost: %s\n" % e)

extern crate BLeagueAuthApi;

pub fn main() {
    let body = Object; // Object

    let mut context = BLeagueAuthApi::Context::default();
    let result = client.bLeagueAuthLinkAccountPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.BLeagueAuthApi;

import java.io.File;
import java.util.*;

public class BLeagueAuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        BLeagueAuthApi apiInstance = new BLeagueAuthApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.bLeagueAuthLoginPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BLeagueAuthApi#bLeagueAuthLoginPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.BLeagueAuthApi;

public class BLeagueAuthApiExample {
    public static void main(String[] args) {
        BLeagueAuthApi apiInstance = new BLeagueAuthApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.bLeagueAuthLoginPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BLeagueAuthApi#bLeagueAuthLoginPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
BLeagueAuthApi *apiInstance = [[BLeagueAuthApi alloc] init];
Object *body = Object; //  (optional)

// login
[apiInstance bLeagueAuthLoginPostWith:body
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.BLeagueAuthApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bLeagueAuthLoginPost(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bLeagueAuthLoginPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new BLeagueAuthApi();
            var body = Object;  // Object |  (optional) 

            try {
                // login
                Object result = apiInstance.bLeagueAuthLoginPost(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BLeagueAuthApi.bLeagueAuthLoginPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BLeagueAuthApi();
$body = Object; // Object | 

try {
    $result = $api_instance->bLeagueAuthLoginPost($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BLeagueAuthApi->bLeagueAuthLoginPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::BLeagueAuthApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BLeagueAuthApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    my $result = $api_instance->bLeagueAuthLoginPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BLeagueAuthApi->bLeagueAuthLoginPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.BLeagueAuthApi()
body = Object # Object |  (optional)

try:
    # login
    api_response = api_instance.b_league_auth_login_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BLeagueAuthApi->bLeagueAuthLoginPost: %s\n" % e)

extern crate BLeagueAuthApi;

pub fn main() {
    let body = Object; // Object

    let mut context = BLeagueAuthApi::Context::default();
    let result = client.bLeagueAuthLoginPost(body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignApi;

import java.io.File;
import java.util.*;

public class CampaignApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        CampaignApi apiInstance = new CampaignApi();

        try {
            apiInstance.campaignGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignApi#campaignGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CampaignApi;

public class CampaignApiExample {
    public static void main(String[] args) {
        CampaignApi apiInstance = new CampaignApi();

        try {
            apiInstance.campaignGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignApi#campaignGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
CampaignApi *apiInstance = [[CampaignApi alloc] init];

// campaign
[apiInstance campaignGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.CampaignApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.campaignGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new CampaignApi();

            try {
                // campaign
                apiInstance.campaignGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignApi.campaignGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignApi();

try {
    $api_instance->campaignGet();
} catch (Exception $e) {
    echo 'Exception when calling CampaignApi->campaignGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignApi->new();

eval {
    $api_instance->campaignGet();
};
if ($@) {
    warn "Exception when calling CampaignApi->campaignGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.CampaignApi()

try:
    # campaign
    api_instance.campaign_get()
except ApiException as e:
    print("Exception when calling CampaignApi->campaignGet: %s\n" % e)

extern crate CampaignApi;

pub fn main() {

    let mut context = CampaignApi::Context::default();
    let result = client.campaignGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignApi;

import java.io.File;
import java.util.*;

public class CampaignApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        CampaignApi apiInstance = new CampaignApi();

        try {
            apiInstance.campaignIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignApi#campaignIndexApiGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CampaignApi;

public class CampaignApiExample {
    public static void main(String[] args) {
        CampaignApi apiInstance = new CampaignApi();

        try {
            apiInstance.campaignIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignApi#campaignIndexApiGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
CampaignApi *apiInstance = [[CampaignApi alloc] init];

// campaign/index_api
[apiInstance campaignIndexApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.CampaignApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.campaignIndexApiGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new CampaignApi();

            try {
                // campaign/index_api
                apiInstance.campaignIndexApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignApi.campaignIndexApiGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignApi();

try {
    $api_instance->campaignIndexApiGet();
} catch (Exception $e) {
    echo 'Exception when calling CampaignApi->campaignIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignApi->new();

eval {
    $api_instance->campaignIndexApiGet();
};
if ($@) {
    warn "Exception when calling CampaignApi->campaignIndexApiGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.CampaignApi()

try:
    # campaign/index_api
    api_instance.campaign_index_api_get()
except ApiException as e:
    print("Exception when calling CampaignApi->campaignIndexApiGet: %s\n" % e)

extern crate CampaignApi;

pub fn main() {

    let mut context = CampaignApi::Context::default();
    let result = client.campaignIndexApiGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignApi;

import java.io.File;
import java.util.*;

public class CampaignApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        CampaignApi apiInstance = new CampaignApi();

        try {
            apiInstance.campaignToBackupApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignApi#campaignToBackupApiGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CampaignApi;

public class CampaignApiExample {
    public static void main(String[] args) {
        CampaignApi apiInstance = new CampaignApi();

        try {
            apiInstance.campaignToBackupApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignApi#campaignToBackupApiGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
CampaignApi *apiInstance = [[CampaignApi alloc] init];

// campaign/to_backup_api
[apiInstance campaignToBackupApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.CampaignApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.campaignToBackupApiGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignToBackupApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new CampaignApi();

            try {
                // campaign/to_backup_api
                apiInstance.campaignToBackupApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignApi.campaignToBackupApiGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignApi();

try {
    $api_instance->campaignToBackupApiGet();
} catch (Exception $e) {
    echo 'Exception when calling CampaignApi->campaignToBackupApiGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignApi->new();

eval {
    $api_instance->campaignToBackupApiGet();
};
if ($@) {
    warn "Exception when calling CampaignApi->campaignToBackupApiGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.CampaignApi()

try:
    # campaign/to_backup_api
    api_instance.campaign_to_backup_api_get()
except ApiException as e:
    print("Exception when calling CampaignApi->campaignToBackupApiGet: %s\n" % e)

extern crate CampaignApi;

pub fn main() {

    let mut context = CampaignApi::Context::default();
    let result = client.campaignToBackupApiGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignApi;

import java.io.File;
import java.util.*;

public class CampaignApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        CampaignApi apiInstance = new CampaignApi();

        try {
            apiInstance.campaignToBackupGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignApi#campaignToBackupGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CampaignApi;

public class CampaignApiExample {
    public static void main(String[] args) {
        CampaignApi apiInstance = new CampaignApi();

        try {
            apiInstance.campaignToBackupGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignApi#campaignToBackupGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
CampaignApi *apiInstance = [[CampaignApi alloc] init];

// campaign/to_backup
[apiInstance campaignToBackupGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.CampaignApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.campaignToBackupGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignToBackupGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new CampaignApi();

            try {
                // campaign/to_backup
                apiInstance.campaignToBackupGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignApi.campaignToBackupGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignApi();

try {
    $api_instance->campaignToBackupGet();
} catch (Exception $e) {
    echo 'Exception when calling CampaignApi->campaignToBackupGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignApi->new();

eval {
    $api_instance->campaignToBackupGet();
};
if ($@) {
    warn "Exception when calling CampaignApi->campaignToBackupGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.CampaignApi()

try:
    # campaign/to_backup
    api_instance.campaign_to_backup_get()
except ApiException as e:
    print("Exception when calling CampaignApi->campaignToBackupGet: %s\n" % e)

extern crate CampaignApi;

pub fn main() {

    let mut context = CampaignApi::Context::default();
    let result = client.campaignToBackupGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CardSeriesVoteApi;

import java.io.File;
import java.util.*;

public class CardSeriesVoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        CardSeriesVoteApi apiInstance = new CardSeriesVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.cardSeriesVoteGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardSeriesVoteApi#cardSeriesVoteGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CardSeriesVoteApi;

public class CardSeriesVoteApiExample {
    public static void main(String[] args) {
        CardSeriesVoteApi apiInstance = new CardSeriesVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.cardSeriesVoteGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardSeriesVoteApi#cardSeriesVoteGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
CardSeriesVoteApi *apiInstance = [[CardSeriesVoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)
String *targetYear = yyyy; //  (optional) (default to null)

// card_series_vote
[apiInstance cardSeriesVoteGetWith:userAgent
    targetYear:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.CardSeriesVoteApi()
var opts = {
  'userAgent': userAgent_example, // {String} 
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.cardSeriesVoteGet(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class cardSeriesVoteGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new CardSeriesVoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // card_series_vote
                apiInstance.cardSeriesVoteGet(userAgent, targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling CardSeriesVoteApi.cardSeriesVoteGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CardSeriesVoteApi();
$userAgent = userAgent_example; // String | 
$targetYear = yyyy; // String | 

try {
    $api_instance->cardSeriesVoteGet($userAgent, $targetYear);
} catch (Exception $e) {
    echo 'Exception when calling CardSeriesVoteApi->cardSeriesVoteGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CardSeriesVoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CardSeriesVoteApi->new();
my $userAgent = userAgent_example; # String | 
my $targetYear = yyyy; # String | 

eval {
    $api_instance->cardSeriesVoteGet(userAgent => $userAgent, targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling CardSeriesVoteApi->cardSeriesVoteGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.CardSeriesVoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)
targetYear = yyyy # String |  (optional) (default to null)

try:
    # card_series_vote
    api_instance.card_series_vote_get(userAgent=userAgent, targetYear=targetYear)
except ApiException as e:
    print("Exception when calling CardSeriesVoteApi->cardSeriesVoteGet: %s\n" % e)

extern crate CardSeriesVoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let targetYear = yyyy; // String

    let mut context = CardSeriesVoteApi::Context::default();
    let result = client.cardSeriesVoteGet(userAgent, targetYear, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CardSeriesVoteApi;

import java.io.File;
import java.util.*;

public class CardSeriesVoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        CardSeriesVoteApi apiInstance = new CardSeriesVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.cardSeriesVoteIndexApiGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardSeriesVoteApi#cardSeriesVoteIndexApiGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CardSeriesVoteApi;

public class CardSeriesVoteApiExample {
    public static void main(String[] args) {
        CardSeriesVoteApi apiInstance = new CardSeriesVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.cardSeriesVoteIndexApiGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardSeriesVoteApi#cardSeriesVoteIndexApiGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
CardSeriesVoteApi *apiInstance = [[CardSeriesVoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)
String *targetYear = yyyy; //  (optional) (default to null)

// card_series_vote/index_api
[apiInstance cardSeriesVoteIndexApiGetWith:userAgent
    targetYear:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.CardSeriesVoteApi()
var opts = {
  'userAgent': userAgent_example, // {String} 
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.cardSeriesVoteIndexApiGet(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class cardSeriesVoteIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new CardSeriesVoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // card_series_vote/index_api
                apiInstance.cardSeriesVoteIndexApiGet(userAgent, targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling CardSeriesVoteApi.cardSeriesVoteIndexApiGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CardSeriesVoteApi();
$userAgent = userAgent_example; // String | 
$targetYear = yyyy; // String | 

try {
    $api_instance->cardSeriesVoteIndexApiGet($userAgent, $targetYear);
} catch (Exception $e) {
    echo 'Exception when calling CardSeriesVoteApi->cardSeriesVoteIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CardSeriesVoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CardSeriesVoteApi->new();
my $userAgent = userAgent_example; # String | 
my $targetYear = yyyy; # String | 

eval {
    $api_instance->cardSeriesVoteIndexApiGet(userAgent => $userAgent, targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling CardSeriesVoteApi->cardSeriesVoteIndexApiGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.CardSeriesVoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)
targetYear = yyyy # String |  (optional) (default to null)

try:
    # card_series_vote/index_api
    api_instance.card_series_vote_index_api_get(userAgent=userAgent, targetYear=targetYear)
except ApiException as e:
    print("Exception when calling CardSeriesVoteApi->cardSeriesVoteIndexApiGet: %s\n" % e)

extern crate CardSeriesVoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let targetYear = yyyy; // String

    let mut context = CardSeriesVoteApi::Context::default();
    let result = client.cardSeriesVoteIndexApiGet(userAgent, targetYear, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ClassMissionApi;

import java.io.File;
import java.util.*;

public class ClassMissionApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ClassMissionApi apiInstance = new ClassMissionApi();

        try {
            apiInstance.classMissionGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ClassMissionApi#classMissionGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ClassMissionApi;

public class ClassMissionApiExample {
    public static void main(String[] args) {
        ClassMissionApi apiInstance = new ClassMissionApi();

        try {
            apiInstance.classMissionGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ClassMissionApi#classMissionGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ClassMissionApi *apiInstance = [[ClassMissionApi alloc] init];

// class_mission
[apiInstance classMissionGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ClassMissionApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.classMissionGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class classMissionGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ClassMissionApi();

            try {
                // class_mission
                apiInstance.classMissionGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ClassMissionApi.classMissionGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ClassMissionApi();

try {
    $api_instance->classMissionGet();
} catch (Exception $e) {
    echo 'Exception when calling ClassMissionApi->classMissionGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ClassMissionApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ClassMissionApi->new();

eval {
    $api_instance->classMissionGet();
};
if ($@) {
    warn "Exception when calling ClassMissionApi->classMissionGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ClassMissionApi()

try:
    # class_mission
    api_instance.class_mission_get()
except ApiException as e:
    print("Exception when calling ClassMissionApi->classMissionGet: %s\n" % e)

extern crate ClassMissionApi;

pub fn main() {

    let mut context = ClassMissionApi::Context::default();
    let result = client.classMissionGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ClassMissionApi;

import java.io.File;
import java.util.*;

public class ClassMissionApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ClassMissionApi apiInstance = new ClassMissionApi();

        try {
            apiInstance.classMissionIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ClassMissionApi#classMissionIndexApiGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ClassMissionApi;

public class ClassMissionApiExample {
    public static void main(String[] args) {
        ClassMissionApi apiInstance = new ClassMissionApi();

        try {
            apiInstance.classMissionIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ClassMissionApi#classMissionIndexApiGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ClassMissionApi *apiInstance = [[ClassMissionApi alloc] init];

// class_mission/index_api
[apiInstance classMissionIndexApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ClassMissionApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.classMissionIndexApiGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class classMissionIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ClassMissionApi();

            try {
                // class_mission/index_api
                apiInstance.classMissionIndexApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ClassMissionApi.classMissionIndexApiGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ClassMissionApi();

try {
    $api_instance->classMissionIndexApiGet();
} catch (Exception $e) {
    echo 'Exception when calling ClassMissionApi->classMissionIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ClassMissionApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ClassMissionApi->new();

eval {
    $api_instance->classMissionIndexApiGet();
};
if ($@) {
    warn "Exception when calling ClassMissionApi->classMissionIndexApiGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ClassMissionApi()

try:
    # class_mission/index_api
    api_instance.class_mission_index_api_get()
except ApiException as e:
    print("Exception when calling ClassMissionApi->classMissionIndexApiGet: %s\n" % e)

extern crate ClassMissionApi;

pub fn main() {

    let mut context = ClassMissionApi::Context::default();
    let result = client.classMissionIndexApiGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DreamteamApi;

import java.io.File;
import java.util.*;

public class DreamteamApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        DreamteamApi apiInstance = new DreamteamApi();
        String targetYear = yyyy; // String | yyyy年のドリームチーム、デフォルト値(今年の)

        try {
            apiInstance.dreamteamGet(targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling DreamteamApi#dreamteamGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DreamteamApi;

public class DreamteamApiExample {
    public static void main(String[] args) {
        DreamteamApi apiInstance = new DreamteamApi();
        String targetYear = yyyy; // String | yyyy年のドリームチーム、デフォルト値(今年の)

        try {
            apiInstance.dreamteamGet(targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling DreamteamApi#dreamteamGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
DreamteamApi *apiInstance = [[DreamteamApi alloc] init];
String *targetYear = yyyy; // yyyy年のドリームチーム、デフォルト値(今年の) (optional) (default to null)

// dreamteam
[apiInstance dreamteamGetWith:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.DreamteamApi()
var opts = {
  'targetYear': yyyy // {String} yyyy年のドリームチーム、デフォルト値(今年の)
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.dreamteamGet(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class dreamteamGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new DreamteamApi();
            var targetYear = yyyy;  // String | yyyy年のドリームチーム、デフォルト値(今年の) (optional)  (default to null)

            try {
                // dreamteam
                apiInstance.dreamteamGet(targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling DreamteamApi.dreamteamGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DreamteamApi();
$targetYear = yyyy; // String | yyyy年のドリームチーム、デフォルト値(今年の)

try {
    $api_instance->dreamteamGet($targetYear);
} catch (Exception $e) {
    echo 'Exception when calling DreamteamApi->dreamteamGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DreamteamApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DreamteamApi->new();
my $targetYear = yyyy; # String | yyyy年のドリームチーム、デフォルト値(今年の)

eval {
    $api_instance->dreamteamGet(targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling DreamteamApi->dreamteamGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.DreamteamApi()
targetYear = yyyy # String | yyyy年のドリームチーム、デフォルト値(今年の) (optional) (default to null)

try:
    # dreamteam
    api_instance.dreamteam_get(targetYear=targetYear)
except ApiException as e:
    print("Exception when calling DreamteamApi->dreamteamGet: %s\n" % e)

extern crate DreamteamApi;

pub fn main() {
    let targetYear = yyyy; // String

    let mut context = DreamteamApi::Context::default();
    let result = client.dreamteamGet(targetYear, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DreamteamApi;

import java.io.File;
import java.util.*;

public class DreamteamApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        DreamteamApi apiInstance = new DreamteamApi();
        String targetYear = yyyy; // String | 

        try {
            apiInstance.dreamteamIndexApiGet(targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling DreamteamApi#dreamteamIndexApiGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DreamteamApi;

public class DreamteamApiExample {
    public static void main(String[] args) {
        DreamteamApi apiInstance = new DreamteamApi();
        String targetYear = yyyy; // String | 

        try {
            apiInstance.dreamteamIndexApiGet(targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling DreamteamApi#dreamteamIndexApiGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
DreamteamApi *apiInstance = [[DreamteamApi alloc] init];
String *targetYear = yyyy; //  (optional) (default to null)

// dreamteam/index_api
[apiInstance dreamteamIndexApiGetWith:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.DreamteamApi()
var opts = {
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.dreamteamIndexApiGet(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class dreamteamIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new DreamteamApi();
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // dreamteam/index_api
                apiInstance.dreamteamIndexApiGet(targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling DreamteamApi.dreamteamIndexApiGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DreamteamApi();
$targetYear = yyyy; // String | 

try {
    $api_instance->dreamteamIndexApiGet($targetYear);
} catch (Exception $e) {
    echo 'Exception when calling DreamteamApi->dreamteamIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DreamteamApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DreamteamApi->new();
my $targetYear = yyyy; # String | 

eval {
    $api_instance->dreamteamIndexApiGet(targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling DreamteamApi->dreamteamIndexApiGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.DreamteamApi()
targetYear = yyyy # String |  (optional) (default to null)

try:
    # dreamteam/index_api
    api_instance.dreamteam_index_api_get(targetYear=targetYear)
except ApiException as e:
    print("Exception when calling DreamteamApi->dreamteamIndexApiGet: %s\n" % e)

extern crate DreamteamApi;

pub fn main() {
    let targetYear = yyyy; // String

    let mut context = DreamteamApi::Context::default();
    let result = client.dreamteamIndexApiGet(targetYear, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DreamteamVoteApi;

import java.io.File;
import java.util.*;

public class DreamteamVoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        DreamteamVoteApi apiInstance = new DreamteamVoteApi();
        String userAgent = userAgent_example; // String | 

        try {
            apiInstance.dreamteamVoteB1Get(userAgent);
        } catch (ApiException e) {
            System.err.println("Exception when calling DreamteamVoteApi#dreamteamVoteB1Get");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DreamteamVoteApi;

public class DreamteamVoteApiExample {
    public static void main(String[] args) {
        DreamteamVoteApi apiInstance = new DreamteamVoteApi();
        String userAgent = userAgent_example; // String | 

        try {
            apiInstance.dreamteamVoteB1Get(userAgent);
        } catch (ApiException e) {
            System.err.println("Exception when calling DreamteamVoteApi#dreamteamVoteB1Get");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
DreamteamVoteApi *apiInstance = [[DreamteamVoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)

// dreamteam_vote/B1
[apiInstance dreamteamVoteB1GetWith:userAgent
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.DreamteamVoteApi()
var opts = {
  'userAgent': userAgent_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.dreamteamVoteB1Get(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class dreamteamVoteB1GetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new DreamteamVoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)

            try {
                // dreamteam_vote/B1
                apiInstance.dreamteamVoteB1Get(userAgent);
            } catch (Exception e) {
                Debug.Print("Exception when calling DreamteamVoteApi.dreamteamVoteB1Get: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DreamteamVoteApi();
$userAgent = userAgent_example; // String | 

try {
    $api_instance->dreamteamVoteB1Get($userAgent);
} catch (Exception $e) {
    echo 'Exception when calling DreamteamVoteApi->dreamteamVoteB1Get: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DreamteamVoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DreamteamVoteApi->new();
my $userAgent = userAgent_example; # String | 

eval {
    $api_instance->dreamteamVoteB1Get(userAgent => $userAgent);
};
if ($@) {
    warn "Exception when calling DreamteamVoteApi->dreamteamVoteB1Get: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.DreamteamVoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)

try:
    # dreamteam_vote/B1
    api_instance.dreamteam_vote_b1_get(userAgent=userAgent)
except ApiException as e:
    print("Exception when calling DreamteamVoteApi->dreamteamVoteB1Get: %s\n" % e)

extern crate DreamteamVoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String

    let mut context = DreamteamVoteApi::Context::default();
    let result = client.dreamteamVoteB1Get(userAgent, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DreamteamVoteApi;

import java.io.File;
import java.util.*;

public class DreamteamVoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        DreamteamVoteApi apiInstance = new DreamteamVoteApi();
        String userAgent = userAgent_example; // String | 

        try {
            apiInstance.dreamteamVoteB2Get(userAgent);
        } catch (ApiException e) {
            System.err.println("Exception when calling DreamteamVoteApi#dreamteamVoteB2Get");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DreamteamVoteApi;

public class DreamteamVoteApiExample {
    public static void main(String[] args) {
        DreamteamVoteApi apiInstance = new DreamteamVoteApi();
        String userAgent = userAgent_example; // String | 

        try {
            apiInstance.dreamteamVoteB2Get(userAgent);
        } catch (ApiException e) {
            System.err.println("Exception when calling DreamteamVoteApi#dreamteamVoteB2Get");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
DreamteamVoteApi *apiInstance = [[DreamteamVoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)

// dreamteam_vote/B2
[apiInstance dreamteamVoteB2GetWith:userAgent
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.DreamteamVoteApi()
var opts = {
  'userAgent': userAgent_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.dreamteamVoteB2Get(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class dreamteamVoteB2GetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new DreamteamVoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)

            try {
                // dreamteam_vote/B2
                apiInstance.dreamteamVoteB2Get(userAgent);
            } catch (Exception e) {
                Debug.Print("Exception when calling DreamteamVoteApi.dreamteamVoteB2Get: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DreamteamVoteApi();
$userAgent = userAgent_example; // String | 

try {
    $api_instance->dreamteamVoteB2Get($userAgent);
} catch (Exception $e) {
    echo 'Exception when calling DreamteamVoteApi->dreamteamVoteB2Get: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DreamteamVoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DreamteamVoteApi->new();
my $userAgent = userAgent_example; # String | 

eval {
    $api_instance->dreamteamVoteB2Get(userAgent => $userAgent);
};
if ($@) {
    warn "Exception when calling DreamteamVoteApi->dreamteamVoteB2Get: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.DreamteamVoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)

try:
    # dreamteam_vote/B2
    api_instance.dreamteam_vote_b2_get(userAgent=userAgent)
except ApiException as e:
    print("Exception when calling DreamteamVoteApi->dreamteamVoteB2Get: %s\n" % e)

extern crate DreamteamVoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String

    let mut context = DreamteamVoteApi::Context::default();
    let result = client.dreamteamVoteB2Get(userAgent, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DreamteamVoteApi;

import java.io.File;
import java.util.*;

public class DreamteamVoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        DreamteamVoteApi apiInstance = new DreamteamVoteApi();
        String userAgent = userAgent_example; // String | 

        try {
            apiInstance.dreamteamVoteIndexApiGet(userAgent);
        } catch (ApiException e) {
            System.err.println("Exception when calling DreamteamVoteApi#dreamteamVoteIndexApiGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DreamteamVoteApi;

public class DreamteamVoteApiExample {
    public static void main(String[] args) {
        DreamteamVoteApi apiInstance = new DreamteamVoteApi();
        String userAgent = userAgent_example; // String | 

        try {
            apiInstance.dreamteamVoteIndexApiGet(userAgent);
        } catch (ApiException e) {
            System.err.println("Exception when calling DreamteamVoteApi#dreamteamVoteIndexApiGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
DreamteamVoteApi *apiInstance = [[DreamteamVoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)

// dreamteam_vote/index_api
[apiInstance dreamteamVoteIndexApiGetWith:userAgent
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.DreamteamVoteApi()
var opts = {
  'userAgent': userAgent_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.dreamteamVoteIndexApiGet(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class dreamteamVoteIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new DreamteamVoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)

            try {
                // dreamteam_vote/index_api
                apiInstance.dreamteamVoteIndexApiGet(userAgent);
            } catch (Exception e) {
                Debug.Print("Exception when calling DreamteamVoteApi.dreamteamVoteIndexApiGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DreamteamVoteApi();
$userAgent = userAgent_example; // String | 

try {
    $api_instance->dreamteamVoteIndexApiGet($userAgent);
} catch (Exception $e) {
    echo 'Exception when calling DreamteamVoteApi->dreamteamVoteIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DreamteamVoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DreamteamVoteApi->new();
my $userAgent = userAgent_example; # String | 

eval {
    $api_instance->dreamteamVoteIndexApiGet(userAgent => $userAgent);
};
if ($@) {
    warn "Exception when calling DreamteamVoteApi->dreamteamVoteIndexApiGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.DreamteamVoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)

try:
    # dreamteam_vote/index_api
    api_instance.dreamteam_vote_index_api_get(userAgent=userAgent)
except ApiException as e:
    print("Exception when calling DreamteamVoteApi->dreamteamVoteIndexApiGet: %s\n" % e)

extern crate DreamteamVoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String

    let mut context = DreamteamVoteApi::Context::default();
    let result = client.dreamteamVoteIndexApiGet(userAgent, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FolderApi;

import java.io.File;
import java.util.*;

public class FolderApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        FolderApi apiInstance = new FolderApi();

        try {
            apiInstance.folderApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FolderApi#folderApiGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FolderApi;

public class FolderApiExample {
    public static void main(String[] args) {
        FolderApi apiInstance = new FolderApi();

        try {
            apiInstance.folderApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FolderApi#folderApiGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
FolderApi *apiInstance = [[FolderApi alloc] init];

// folder_api
[apiInstance folderApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.FolderApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.folderApiGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class folderApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new FolderApi();

            try {
                // folder_api
                apiInstance.folderApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling FolderApi.folderApiGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FolderApi();

try {
    $api_instance->folderApiGet();
} catch (Exception $e) {
    echo 'Exception when calling FolderApi->folderApiGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FolderApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FolderApi->new();

eval {
    $api_instance->folderApiGet();
};
if ($@) {
    warn "Exception when calling FolderApi->folderApiGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.FolderApi()

try:
    # folder_api
    api_instance.folder_api_get()
except ApiException as e:
    print("Exception when calling FolderApi->folderApiGet: %s\n" % e)

extern crate FolderApi;

pub fn main() {

    let mut context = FolderApi::Context::default();
    let result = client.folderApiGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FolderApi;

import java.io.File;
import java.util.*;

public class FolderApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        FolderApi apiInstance = new FolderApi();

        try {
            apiInstance.folderGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FolderApi#folderGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FolderApi;

public class FolderApiExample {
    public static void main(String[] args) {
        FolderApi apiInstance = new FolderApi();

        try {
            apiInstance.folderGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FolderApi#folderGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
FolderApi *apiInstance = [[FolderApi alloc] init];

// folder
[apiInstance folderGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.FolderApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.folderGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class folderGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new FolderApi();

            try {
                // folder
                apiInstance.folderGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling FolderApi.folderGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FolderApi();

try {
    $api_instance->folderGet();
} catch (Exception $e) {
    echo 'Exception when calling FolderApi->folderGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FolderApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FolderApi->new();

eval {
    $api_instance->folderGet();
};
if ($@) {
    warn "Exception when calling FolderApi->folderGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.FolderApi()

try:
    # folder
    api_instance.folder_get()
except ApiException as e:
    print("Exception when calling FolderApi->folderGet: %s\n" % e)

extern crate FolderApi;

pub fn main() {

    let mut context = FolderApi::Context::default();
    let result = client.folderGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastBasicApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastBasicApiGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastBasicApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastBasicApiGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/basic_api
[apiInstance forecastBasicApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastBasicApiGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastBasicApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/basic_api
                apiInstance.forecastBasicApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastBasicApiGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastBasicApiGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastBasicApiGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastBasicApiGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastBasicApiGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/basic_api
    api_instance.forecast_basic_api_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastBasicApiGet: %s\n" % e)

extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastBasicApiGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastBasicGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastBasicGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastBasicGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastBasicGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/basic
[apiInstance forecastBasicGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastBasicGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastBasicGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/basic
                apiInstance.forecastBasicGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastBasicGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastBasicGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastBasicGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastBasicGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastBasicGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/basic
    api_instance.forecast_basic_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastBasicGet: %s\n" % e)

extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastBasicGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastBonusDetailApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastBonusDetailApiGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastBonusDetailApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastBonusDetailApiGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/bonus_detail_api
[apiInstance forecastBonusDetailApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastBonusDetailApiGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastBonusDetailApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/bonus_detail_api
                apiInstance.forecastBonusDetailApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastBonusDetailApiGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastBonusDetailApiGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastBonusDetailApiGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastBonusDetailApiGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastBonusDetailApiGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/bonus_detail_api
    api_instance.forecast_bonus_detail_api_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastBonusDetailApiGet: %s\n" % e)

extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastBonusDetailApiGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastBonusDetailGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastBonusDetailGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastBonusDetailGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastBonusDetailGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/bonus_detail
[apiInstance forecastBonusDetailGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastBonusDetailGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastBonusDetailGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/bonus_detail
                apiInstance.forecastBonusDetailGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastBonusDetailGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastBonusDetailGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastBonusDetailGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastBonusDetailGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastBonusDetailGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/bonus_detail
    api_instance.forecast_bonus_detail_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastBonusDetailGet: %s\n" % e)

extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastBonusDetailGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast
[apiInstance forecastGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast
                apiInstance.forecastGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast
    api_instance.forecast_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastGet: %s\n" % e)

extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastHistoryApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastHistoryApiGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastHistoryApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastHistoryApiGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/history_api
[apiInstance forecastHistoryApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastHistoryApiGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastHistoryApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/history_api
                apiInstance.forecastHistoryApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastHistoryApiGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastHistoryApiGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastHistoryApiGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastHistoryApiGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastHistoryApiGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/history_api
    api_instance.forecast_history_api_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastHistoryApiGet: %s\n" % e)

extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastHistoryApiGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();
        Integer section = 1; // Integer | ${value}節のデータを取得する

        try {
            apiInstance.forecastHistoryDetailApiGet(section);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastHistoryDetailApiGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();
        Integer section = 1; // Integer | ${value}節のデータを取得する

        try {
            apiInstance.forecastHistoryDetailApiGet(section);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastHistoryDetailApiGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];
Integer *section = 1; // ${value}節のデータを取得する (optional) (default to null)

// forecast/history_detail_api
[apiInstance forecastHistoryDetailApiGetWith:section
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var opts = {
  'section': 1 // {Integer} ${value}節のデータを取得する
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastHistoryDetailApiGet(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastHistoryDetailApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();
            var section = 1;  // Integer | ${value}節のデータを取得する (optional)  (default to null)

            try {
                // forecast/history_detail_api
                apiInstance.forecastHistoryDetailApiGet(section);
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastHistoryDetailApiGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();
$section = 1; // Integer | ${value}節のデータを取得する

try {
    $api_instance->forecastHistoryDetailApiGet($section);
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastHistoryDetailApiGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();
my $section = 1; # Integer | ${value}節のデータを取得する

eval {
    $api_instance->forecastHistoryDetailApiGet(section => $section);
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastHistoryDetailApiGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()
section = 1 # Integer | ${value}節のデータを取得する (optional) (default to null)

try:
    # forecast/history_detail_api
    api_instance.forecast_history_detail_api_get(section=section)
except ApiException as e:
    print("Exception when calling ForecastApi->forecastHistoryDetailApiGet: %s\n" % e)

extern crate ForecastApi;

pub fn main() {
    let section = 1; // Integer

    let mut context = ForecastApi::Context::default();
    let result = client.forecastHistoryDetailApiGet(section, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();
        Integer section = 1; // Integer | ${value}節のデータを取得する

        try {
            apiInstance.forecastHistoryDetailGet(section);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastHistoryDetailGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();
        Integer section = 1; // Integer | ${value}節のデータを取得する

        try {
            apiInstance.forecastHistoryDetailGet(section);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastHistoryDetailGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];
Integer *section = 1; // ${value}節のデータを取得する (optional) (default to null)

// forecast/history_detail
[apiInstance forecastHistoryDetailGetWith:section
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var opts = {
  'section': 1 // {Integer} ${value}節のデータを取得する
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastHistoryDetailGet(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastHistoryDetailGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();
            var section = 1;  // Integer | ${value}節のデータを取得する (optional)  (default to null)

            try {
                // forecast/history_detail
                apiInstance.forecastHistoryDetailGet(section);
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastHistoryDetailGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();
$section = 1; // Integer | ${value}節のデータを取得する

try {
    $api_instance->forecastHistoryDetailGet($section);
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastHistoryDetailGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();
my $section = 1; # Integer | ${value}節のデータを取得する

eval {
    $api_instance->forecastHistoryDetailGet(section => $section);
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastHistoryDetailGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()
section = 1 # Integer | ${value}節のデータを取得する (optional) (default to null)

try:
    # forecast/history_detail
    api_instance.forecast_history_detail_get(section=section)
except ApiException as e:
    print("Exception when calling ForecastApi->forecastHistoryDetailGet: %s\n" % e)

extern crate ForecastApi;

pub fn main() {
    let section = 1; // Integer

    let mut context = ForecastApi::Context::default();
    let result = client.forecastHistoryDetailGet(section, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastHistoryGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastHistoryGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastHistoryGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastHistoryGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/history
[apiInstance forecastHistoryGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastHistoryGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastHistoryGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/history
                apiInstance.forecastHistoryGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastHistoryGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastHistoryGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastHistoryGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastHistoryGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastHistoryGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/history
    api_instance.forecast_history_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastHistoryGet: %s\n" % e)

extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastHistoryGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastIndexApiGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastIndexApiGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/index_api
[apiInstance forecastIndexApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastIndexApiGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/index_api
                apiInstance.forecastIndexApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastIndexApiGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastIndexApiGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastIndexApiGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastIndexApiGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/index_api
    api_instance.forecast_index_api_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastIndexApiGet: %s\n" % e)

extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastIndexApiGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastRankingApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastRankingApiGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastRankingApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastRankingApiGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/ranking_api
[apiInstance forecastRankingApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastRankingApiGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastRankingApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/ranking_api
                apiInstance.forecastRankingApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastRankingApiGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastRankingApiGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastRankingApiGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastRankingApiGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastRankingApiGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/ranking_api
    api_instance.forecast_ranking_api_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastRankingApiGet: %s\n" % e)

extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastRankingApiGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastRankingGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastRankingGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastRankingGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastRankingGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/ranking
[apiInstance forecastRankingGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastRankingGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastRankingGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/ranking
                apiInstance.forecastRankingGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastRankingGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastRankingGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastRankingGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastRankingGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastRankingGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/ranking
    api_instance.forecast_ranking_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastRankingGet: %s\n" % e)

extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastRankingGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();
        String r = b; // String | 

        try {
            Object result = apiInstance.forecastResultEffectApiGet(r);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastResultEffectApiGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();
        String r = b; // String | 

        try {
            Object result = apiInstance.forecastResultEffectApiGet(r);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastResultEffectApiGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];
String *r = b; //  (optional) (default to null)

// forecast/result_effect_api
[apiInstance forecastResultEffectApiGetWith:r
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var opts = {
  'r': b // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.forecastResultEffectApiGet(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastResultEffectApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();
            var r = b;  // String |  (optional)  (default to null)

            try {
                // forecast/result_effect_api
                Object result = apiInstance.forecastResultEffectApiGet(r);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastResultEffectApiGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();
$r = b; // String | 

try {
    $result = $api_instance->forecastResultEffectApiGet($r);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastResultEffectApiGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();
my $r = b; # String | 

eval {
    my $result = $api_instance->forecastResultEffectApiGet(r => $r);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastResultEffectApiGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()
r = b # String |  (optional) (default to null)

try:
    # forecast/result_effect_api
    api_response = api_instance.forecast_result_effect_api_get(r=r)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ForecastApi->forecastResultEffectApiGet: %s\n" % e)

extern crate ForecastApi;

pub fn main() {
    let r = b; // String

    let mut context = ForecastApi::Context::default();
    let result = client.forecastResultEffectApiGet(r, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();
        String r = b; // String | 

        try {
            apiInstance.forecastResultEffectGet(r);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastResultEffectGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();
        String r = b; // String | 

        try {
            apiInstance.forecastResultEffectGet(r);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastResultEffectGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];
String *r = b; //  (optional) (default to null)

// forecast/result_effect
[apiInstance forecastResultEffectGetWith:r
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var opts = {
  'r': b // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastResultEffectGet(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastResultEffectGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();
            var r = b;  // String |  (optional)  (default to null)

            try {
                // forecast/result_effect
                apiInstance.forecastResultEffectGet(r);
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastResultEffectGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();
$r = b; // String | 

try {
    $api_instance->forecastResultEffectGet($r);
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastResultEffectGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();
my $r = b; # String | 

eval {
    $api_instance->forecastResultEffectGet(r => $r);
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastResultEffectGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()
r = b # String |  (optional) (default to null)

try:
    # forecast/result_effect
    api_instance.forecast_result_effect_get(r=r)
except ApiException as e:
    print("Exception when calling ForecastApi->forecastResultEffectGet: %s\n" % e)

extern crate ForecastApi;

pub fn main() {
    let r = b; // String

    let mut context = ForecastApi::Context::default();
    let result = client.forecastResultEffectGet(r, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastRewardApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastRewardApiGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastRewardApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastRewardApiGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/reward_api
[apiInstance forecastRewardApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastRewardApiGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastRewardApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/reward_api
                apiInstance.forecastRewardApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastRewardApiGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastRewardApiGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastRewardApiGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastRewardApiGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastRewardApiGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/reward_api
    api_instance.forecast_reward_api_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastRewardApiGet: %s\n" % e)

extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastRewardApiGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastRewardGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastRewardGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastRewardGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastRewardGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/reward
[apiInstance forecastRewardGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastRewardGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastRewardGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/reward
                apiInstance.forecastRewardGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastRewardGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastRewardGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastRewardGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastRewardGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastRewardGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/reward
    api_instance.forecast_reward_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastRewardGet: %s\n" % e)

extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastRewardGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();
        Integer slot = 3; // Integer | 
        Integer section = 21; // Integer | 節

        try {
            Object result = apiInstance.forecastScoreDetailApiGet(slot, section);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastScoreDetailApiGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();
        Integer slot = 3; // Integer | 
        Integer section = 21; // Integer | 節

        try {
            Object result = apiInstance.forecastScoreDetailApiGet(slot, section);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastScoreDetailApiGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];
Integer *slot = 3; //  (optional) (default to null)
Integer *section = 21; // 節 (optional) (default to null)

// forecast/score_detail_api
[apiInstance forecastScoreDetailApiGetWith:slot
    section:section
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var opts = {
  'slot': 3, // {Integer} 
  'section': 21 // {Integer} 節
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.forecastScoreDetailApiGet(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastScoreDetailApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();
            var slot = 3;  // Integer |  (optional)  (default to null)
            var section = 21;  // Integer | 節 (optional)  (default to null)

            try {
                // forecast/score_detail_api
                Object result = apiInstance.forecastScoreDetailApiGet(slot, section);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastScoreDetailApiGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();
$slot = 3; // Integer | 
$section = 21; // Integer | 節

try {
    $result = $api_instance->forecastScoreDetailApiGet($slot, $section);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastScoreDetailApiGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();
my $slot = 3; # Integer | 
my $section = 21; # Integer | 節

eval {
    my $result = $api_instance->forecastScoreDetailApiGet(slot => $slot, section => $section);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastScoreDetailApiGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()
slot = 3 # Integer |  (optional) (default to null)
section = 21 # Integer | 節 (optional) (default to null)

try:
    # forecast/score_detail_api
    api_response = api_instance.forecast_score_detail_api_get(slot=slot, section=section)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ForecastApi->forecastScoreDetailApiGet: %s\n" % e)

extern crate ForecastApi;

pub fn main() {
    let slot = 3; // Integer
    let section = 21; // Integer

    let mut context = ForecastApi::Context::default();
    let result = client.forecastScoreDetailApiGet(slot, section, &context).wait();

    println!("{:?}", result);
}